﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class OdDbTable : OdDbBlockReference
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public OdDbTable(IntPtr cPtr, bool cMemoryOwn) : base(TD_DbPINVOKE.OdDbTable_SWIGUpcast(cPtr), cMemoryOwn)
		{
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(OdDbTable obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~OdDbTable()
		{
			this.Dispose();
		}

		public override void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_OdDbTable(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
			base.Dispose();
		}

		public new static OdDbTable cast(OdRxObject pObj)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbTable_cast(OdRxObject.getCPtr(pObj));
			OdDbTable result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbTable)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbTable)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbTable)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdRxClass desc()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbTable_desc(), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxClass isA()
		{
			OdRxClass result = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbTable_isA(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdRxObject queryX(OdRxClass protocolClass)
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.OdDbTable_queryX(this.swigCPtr, OdRxClass.getCPtr(protocolClass)), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new static OdDbTable createObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbTable_createObject();
			OdDbTable result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbTable)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbTable)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbTable)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObjectId tableStyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_tableStyle(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTableStyle(OdDbObjectId tableStyleId)
		{
			TD_DbPINVOKE.OdDbTable_setTableStyle(this.swigCPtr, OdDbObjectId.getCPtr(tableStyleId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGeVector3d direction()
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbTable_direction(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setDirection(OdGeVector3d horizVector)
		{
			TD_DbPINVOKE.OdDbTable_setDirection(this.swigCPtr, OdGeVector3d.getCPtr(horizVector));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual uint numRows()
		{
			uint result = TD_DbPINVOKE.OdDbTable_numRows(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setNumRows(uint numRows)
		{
			TD_DbPINVOKE.OdDbTable_setNumRows(this.swigCPtr, numRows);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual uint numColumns()
		{
			uint result = TD_DbPINVOKE.OdDbTable_numColumns(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setNumColumns(uint numColumns)
		{
			TD_DbPINVOKE.OdDbTable_setNumColumns(this.swigCPtr, numColumns);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double width()
		{
			double result = TD_DbPINVOKE.OdDbTable_width(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setWidth(double width)
		{
			TD_DbPINVOKE.OdDbTable_setWidth(this.swigCPtr, width);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double columnWidth(uint column)
		{
			double result = TD_DbPINVOKE.OdDbTable_columnWidth(this.swigCPtr, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setColumnWidth(uint column, double width)
		{
			TD_DbPINVOKE.OdDbTable_setColumnWidth__SWIG_0(this.swigCPtr, column, width);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setColumnWidth(double width)
		{
			TD_DbPINVOKE.OdDbTable_setColumnWidth__SWIG_1(this.swigCPtr, width);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double height()
		{
			double result = TD_DbPINVOKE.OdDbTable_height(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHeight(double height)
		{
			TD_DbPINVOKE.OdDbTable_setHeight(this.swigCPtr, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double rowHeight(uint row)
		{
			double result = TD_DbPINVOKE.OdDbTable_rowHeight(this.swigCPtr, row);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setRowHeight(uint row, double height)
		{
			TD_DbPINVOKE.OdDbTable_setRowHeight__SWIG_0(this.swigCPtr, row, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setRowHeight(double height)
		{
			TD_DbPINVOKE.OdDbTable_setRowHeight__SWIG_1(this.swigCPtr, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double minimumColumnWidth(uint column)
		{
			double result = TD_DbPINVOKE.OdDbTable_minimumColumnWidth(this.swigCPtr, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double minimumRowHeight(uint row)
		{
			double result = TD_DbPINVOKE.OdDbTable_minimumRowHeight(this.swigCPtr, row);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double minimumTableWidth()
		{
			double result = TD_DbPINVOKE.OdDbTable_minimumTableWidth(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double minimumTableHeight()
		{
			double result = TD_DbPINVOKE.OdDbTable_minimumTableHeight(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double horzCellMargin()
		{
			double result = TD_DbPINVOKE.OdDbTable_horzCellMargin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setHorzCellMargin(double cellMargin)
		{
			TD_DbPINVOKE.OdDbTable_setHorzCellMargin(this.swigCPtr, cellMargin);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double vertCellMargin()
		{
			double result = TD_DbPINVOKE.OdDbTable_vertCellMargin(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setVertCellMargin(double cellMargin)
		{
			TD_DbPINVOKE.OdDbTable_setVertCellMargin(this.swigCPtr, cellMargin);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual FlowDirection flowDirection()
		{
			FlowDirection result = (FlowDirection)TD_DbPINVOKE.OdDbTable_flowDirection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFlowDirection(FlowDirection flowDirection)
		{
			TD_DbPINVOKE.OdDbTable_setFlowDirection(this.swigCPtr, (int)flowDirection);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isTitleSuppressed()
		{
			bool result = TD_DbPINVOKE.OdDbTable_isTitleSuppressed(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void suppressTitleRow(bool suppress)
		{
			TD_DbPINVOKE.OdDbTable_suppressTitleRow(this.swigCPtr, suppress);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isHeaderSuppressed()
		{
			bool result = TD_DbPINVOKE.OdDbTable_isHeaderSuppressed(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void suppressHeaderRow(bool suppress)
		{
			TD_DbPINVOKE.OdDbTable_suppressHeaderRow(this.swigCPtr, suppress);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual CellAlignment alignment(RowType rowType)
		{
			CellAlignment result = (CellAlignment)TD_DbPINVOKE.OdDbTable_alignment__SWIG_0(this.swigCPtr, (int)rowType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual CellAlignment alignment()
		{
			CellAlignment result = (CellAlignment)TD_DbPINVOKE.OdDbTable_alignment__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual CellAlignment alignment(uint row, uint column)
		{
			CellAlignment result = (CellAlignment)TD_DbPINVOKE.OdDbTable_alignment__SWIG_2(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setAlignment(CellAlignment alignment, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setAlignment__SWIG_0(this.swigCPtr, (int)alignment, rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setAlignment(CellAlignment alignment)
		{
			TD_DbPINVOKE.OdDbTable_setAlignment__SWIG_1(this.swigCPtr, (int)alignment);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setAlignment(uint row, uint column, CellAlignment alignment)
		{
			TD_DbPINVOKE.OdDbTable_setAlignment__SWIG_2(this.swigCPtr, row, column, (int)alignment);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isBackgroundColorNone(RowType rowType)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isBackgroundColorNone__SWIG_0(this.swigCPtr, (int)rowType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isBackgroundColorNone()
		{
			bool result = TD_DbPINVOKE.OdDbTable_isBackgroundColorNone__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isBackgroundColorNone(uint row, uint column)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isBackgroundColorNone__SWIG_2(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setBackgroundColorNone(bool disable, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setBackgroundColorNone__SWIG_0(this.swigCPtr, disable, rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setBackgroundColorNone(bool disable)
		{
			TD_DbPINVOKE.OdDbTable_setBackgroundColorNone__SWIG_1(this.swigCPtr, disable);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setBackgroundColorNone(uint row, uint column, bool disable)
		{
			TD_DbPINVOKE.OdDbTable_setBackgroundColorNone__SWIG_2(this.swigCPtr, row, column, disable);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor backgroundColor(RowType rowType)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_backgroundColor__SWIG_0(this.swigCPtr, (int)rowType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor backgroundColor()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_backgroundColor__SWIG_1(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor backgroundColor(uint row, uint column)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_backgroundColor__SWIG_2(this.swigCPtr, row, column), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setBackgroundColor(OdCmColor color, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setBackgroundColor__SWIG_0(this.swigCPtr, OdCmColor.getCPtr(color), rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setBackgroundColor(OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setBackgroundColor__SWIG_1(this.swigCPtr, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setBackgroundColor(uint row, uint column, OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setBackgroundColor__SWIG_2(this.swigCPtr, row, column, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor contentColor(RowType rowType)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_contentColor__SWIG_0(this.swigCPtr, (int)rowType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor contentColor()
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_contentColor__SWIG_1(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor contentColor(uint row, uint column)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_contentColor__SWIG_2(this.swigCPtr, row, column), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setContentColor(OdCmColor color, uint nRowType)
		{
			TD_DbPINVOKE.OdDbTable_setContentColor__SWIG_0(this.swigCPtr, OdCmColor.getCPtr(color), nRowType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setContentColor(OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setContentColor__SWIG_1(this.swigCPtr, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setContentColor(uint row, uint column, OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setContentColor__SWIG_2(this.swigCPtr, row, column, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId textStyle(RowType rowType)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_textStyle__SWIG_0(this.swigCPtr, (int)rowType);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObjectId textStyle()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_textStyle__SWIG_1(this.swigCPtr);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbObjectId textStyle(uint row, uint column)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_textStyle__SWIG_2(this.swigCPtr, row, column);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTextStyle(OdDbObjectId textStyleId, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setTextStyle__SWIG_0(this.swigCPtr, OdDbObjectId.getCPtr(textStyleId), rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setTextStyle(OdDbObjectId textStyleId)
		{
			TD_DbPINVOKE.OdDbTable_setTextStyle__SWIG_1(this.swigCPtr, OdDbObjectId.getCPtr(textStyleId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setTextStyle(uint row, uint column, OdDbObjectId textStyleId)
		{
			TD_DbPINVOKE.OdDbTable_setTextStyle__SWIG_2(this.swigCPtr, row, column, OdDbObjectId.getCPtr(textStyleId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double textHeight(RowType rowType)
		{
			double result = TD_DbPINVOKE.OdDbTable_textHeight__SWIG_0(this.swigCPtr, (int)rowType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double textHeight()
		{
			double result = TD_DbPINVOKE.OdDbTable_textHeight__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double textHeight(uint row, uint column)
		{
			double result = TD_DbPINVOKE.OdDbTable_textHeight__SWIG_2(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTextHeight(double height, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setTextHeight__SWIG_0(this.swigCPtr, height, rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setTextHeight(double height)
		{
			TD_DbPINVOKE.OdDbTable_setTextHeight__SWIG_1(this.swigCPtr, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setTextHeight(uint row, uint column, double height)
		{
			TD_DbPINVOKE.OdDbTable_setTextHeight__SWIG_2(this.swigCPtr, row, column, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual LineWeight gridLineWeight(GridLineType gridlineType, RowType rowType)
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbTable_gridLineWeight__SWIG_0(this.swigCPtr, (int)gridlineType, (int)rowType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual LineWeight gridLineWeight(GridLineType gridlineType)
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbTable_gridLineWeight__SWIG_1(this.swigCPtr, (int)gridlineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual LineWeight gridLineWeight(uint row, uint column, CellEdgeMask edgeType)
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbTable_gridLineWeight__SWIG_2(this.swigCPtr, row, column, (int)edgeType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setGridLineWeight(LineWeight lineWeight, uint gridlineTypes, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setGridLineWeight__SWIG_0(this.swigCPtr, (int)lineWeight, gridlineTypes, rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setGridLineWeight(uint row, uint column, short edgeTypes, LineWeight lineWeight)
		{
			TD_DbPINVOKE.OdDbTable_setGridLineWeight__SWIG_1(this.swigCPtr, row, column, edgeTypes, (int)lineWeight);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdCmColor gridColor(GridLineType gridlineType, RowType rowType)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_gridColor__SWIG_0(this.swigCPtr, (int)gridlineType, (int)rowType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor gridColor(GridLineType gridlineType)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_gridColor__SWIG_1(this.swigCPtr, (int)gridlineType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor gridColor(uint row, uint column, CellEdgeMask edgeType)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_gridColor__SWIG_2(this.swigCPtr, row, column, (int)edgeType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual Visibility gridVisibility(GridLineType gridlineType, RowType rowType)
		{
			Visibility result = (Visibility)TD_DbPINVOKE.OdDbTable_gridVisibility__SWIG_0(this.swigCPtr, (int)gridlineType, (int)rowType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual Visibility gridVisibility(GridLineType gridlineType)
		{
			Visibility result = (Visibility)TD_DbPINVOKE.OdDbTable_gridVisibility__SWIG_1(this.swigCPtr, (int)gridlineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual Visibility gridVisibility(uint row, uint column, CellEdgeMask edgeType)
		{
			Visibility result = (Visibility)TD_DbPINVOKE.OdDbTable_gridVisibility__SWIG_2(this.swigCPtr, row, column, (int)edgeType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setGridVisibility(Visibility gridVisiblity, uint gridlineTypes, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setGridVisibility__SWIG_0(this.swigCPtr, (int)gridVisiblity, gridlineTypes, rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setGridVisibility(uint row, uint column, short edgeTypes, Visibility gridVisibility)
		{
			TD_DbPINVOKE.OdDbTable_setGridVisibility__SWIG_1(this.swigCPtr, row, column, edgeTypes, (int)gridVisibility);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool tableStyleOverrides(OdUInt32Array overrides)
		{
			bool result = TD_DbPINVOKE.OdDbTable_tableStyleOverrides(this.swigCPtr, OdUInt32Array.getCPtr(overrides).Handle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void clearTableStyleOverrides(int option)
		{
			TD_DbPINVOKE.OdDbTable_clearTableStyleOverrides__SWIG_0(this.swigCPtr, option);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void clearTableStyleOverrides()
		{
			TD_DbPINVOKE.OdDbTable_clearTableStyleOverrides__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual CellType cellType(uint row, uint column)
		{
			CellType result = (CellType)TD_DbPINVOKE.OdDbTable_cellType(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setCellType(uint row, uint column, CellType cellType)
		{
			TD_DbPINVOKE.OdDbTable_setCellType(this.swigCPtr, row, column, (int)cellType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void getCellExtents(uint row, uint column, bool isOuterCell, OdGePoint3dArray pts)
		{
			TD_DbPINVOKE.OdDbTable_getCellExtents(this.swigCPtr, row, column, isOuterCell, OdGePoint3dArray.getCPtr(pts));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdGePoint3d attachmentPoint(uint row, uint column)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbTable_attachmentPoint__SWIG_0(this.swigCPtr, row, column), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool cellStyleOverrides(uint row, uint column, OdUInt32Array overrides)
		{
			bool result = TD_DbPINVOKE.OdDbTable_cellStyleOverrides(this.swigCPtr, row, column, OdUInt32Array.getCPtr(overrides).Handle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void clearCellOverrides(uint row, uint column)
		{
			TD_DbPINVOKE.OdDbTable_clearCellOverrides(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void deleteCellContent(uint row, uint column)
		{
			TD_DbPINVOKE.OdDbTable_deleteCellContent(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual RowType rowType(uint row)
		{
			RowType result = (RowType)TD_DbPINVOKE.OdDbTable_rowType(this.swigCPtr, row);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string textString(uint row, uint column)
		{
			string result = TD_DbPINVOKE.OdDbTable_textString__SWIG_0(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTextString(uint row, uint column, string textString)
		{
			TD_DbPINVOKE.OdDbTable_setTextString__SWIG_0(this.swigCPtr, row, column, textString);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId fieldId(uint row, uint column)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_fieldId__SWIG_0(this.swigCPtr, row, column);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFieldId(uint row, uint column, OdDbObjectId fieldId)
		{
			TD_DbPINVOKE.OdDbTable_setFieldId__SWIG_0(this.swigCPtr, row, column, OdDbObjectId.getCPtr(fieldId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual RotationAngle textRotation(uint row, uint column)
		{
			RotationAngle result = (RotationAngle)TD_DbPINVOKE.OdDbTable_textRotation(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setTextRotation(uint row, uint column, RotationAngle textRotation)
		{
			TD_DbPINVOKE.OdDbTable_setTextRotation(this.swigCPtr, row, column, (int)textRotation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isAutoScale(uint row, uint column)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isAutoScale__SWIG_0(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setAutoScale(uint row, uint column, bool autoScale)
		{
			TD_DbPINVOKE.OdDbTable_setAutoScale__SWIG_0(this.swigCPtr, row, column, autoScale);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdDbObjectId blockTableRecordId(uint row, uint column)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_blockTableRecordId__SWIG_0(this.swigCPtr, row, column);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setBlockTableRecordId(uint row, uint column, OdDbObjectId blockId, bool autoScale)
		{
			TD_DbPINVOKE.OdDbTable_setBlockTableRecordId__SWIG_0(this.swigCPtr, row, column, OdDbObjectId.getCPtr(blockId), autoScale);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setBlockTableRecordId(uint row, uint column, OdDbObjectId blockId)
		{
			TD_DbPINVOKE.OdDbTable_setBlockTableRecordId__SWIG_1(this.swigCPtr, row, column, OdDbObjectId.getCPtr(blockId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double blockScale(uint row, uint column)
		{
			double result = TD_DbPINVOKE.OdDbTable_blockScale(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setBlockScale(uint row, uint column, double blockScale)
		{
			TD_DbPINVOKE.OdDbTable_setBlockScale(this.swigCPtr, row, column, blockScale);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual double blockRotation(uint row, uint column)
		{
			double result = TD_DbPINVOKE.OdDbTable_blockRotation(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setBlockRotation(uint row, uint column, double blockRotation)
		{
			TD_DbPINVOKE.OdDbTable_setBlockRotation(this.swigCPtr, row, column, blockRotation);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void getBlockAttributeValue(uint row, uint column, OdDbObjectId attdefId, ref string attValue)
		{
			IntPtr intPtr = Marshal.StringToCoTaskMemUni(attValue);
			IntPtr value = intPtr;
			try
			{
				TD_DbPINVOKE.OdDbTable_getBlockAttributeValue__SWIG_0(this.swigCPtr, row, column, OdDbObjectId.getCPtr(attdefId), ref intPtr);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				if (intPtr != value)
				{
					attValue = Marshal.PtrToStringUni(intPtr);
				}
			}
		}

		public virtual void setBlockAttributeValue(uint row, uint column, OdDbObjectId attdefId, string attValue)
		{
			TD_DbPINVOKE.OdDbTable_setBlockAttributeValue__SWIG_0(this.swigCPtr, row, column, OdDbObjectId.getCPtr(attdefId), attValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setGridColor(OdCmColor color, uint gridlineTypes, uint rowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setGridColor__SWIG_0(this.swigCPtr, OdCmColor.getCPtr(color), gridlineTypes, rowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setGridColor(uint row, uint column, short edgeTypes, OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setGridColor__SWIG_1(this.swigCPtr, row, column, edgeTypes, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void insertColumns(uint column, double width, uint numColumns)
		{
			TD_DbPINVOKE.OdDbTable_insertColumns__SWIG_0(this.swigCPtr, column, width, numColumns);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void insertColumns(uint column, double width)
		{
			TD_DbPINVOKE.OdDbTable_insertColumns__SWIG_1(this.swigCPtr, column, width);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void deleteColumns(uint column, uint numColumns)
		{
			TD_DbPINVOKE.OdDbTable_deleteColumns__SWIG_0(this.swigCPtr, column, numColumns);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void deleteColumns(uint column)
		{
			TD_DbPINVOKE.OdDbTable_deleteColumns__SWIG_1(this.swigCPtr, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void insertRows(uint row, double height, uint numRows)
		{
			TD_DbPINVOKE.OdDbTable_insertRows__SWIG_0(this.swigCPtr, row, height, numRows);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void insertRows(uint row, double height)
		{
			TD_DbPINVOKE.OdDbTable_insertRows__SWIG_1(this.swigCPtr, row, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void deleteRows(uint row, uint numRows)
		{
			TD_DbPINVOKE.OdDbTable_deleteRows__SWIG_0(this.swigCPtr, row, numRows);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void deleteRows(uint row)
		{
			TD_DbPINVOKE.OdDbTable_deleteRows__SWIG_1(this.swigCPtr, row);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void mergeCells(uint minRow, uint maxRow, uint minColumn, uint maxColumn)
		{
			TD_DbPINVOKE.OdDbTable_mergeCells(this.swigCPtr, minRow, maxRow, minColumn, maxColumn);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void unmergeCells(uint minRow, uint maxRow, uint minColumn, uint maxColumn)
		{
			TD_DbPINVOKE.OdDbTable_unmergeCells(this.swigCPtr, minRow, maxRow, minColumn, maxColumn);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool isMergedCell(uint row, uint column, out uint minRow, out uint maxRow, out uint minColumn, out uint maxColumn)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isMergedCell__SWIG_0(this.swigCPtr, row, column, out minRow, out maxRow, out minColumn, out maxColumn);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isMergedCell(uint row, uint column, out uint minRow, out uint maxRow, out uint minColumn)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isMergedCell__SWIG_1(this.swigCPtr, row, column, out minRow, out maxRow, out minColumn);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isMergedCell(uint row, uint column, out uint minRow, out uint maxRow)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isMergedCell__SWIG_2(this.swigCPtr, row, column, out minRow, out maxRow);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isMergedCell(uint row, uint column, out uint minRow)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isMergedCell__SWIG_3(this.swigCPtr, row, column, out minRow);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool isMergedCell(uint row, uint column)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isMergedCell__SWIG_4(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public uint mergedHeight(uint row, uint column)
		{
			uint result = TD_DbPINVOKE.OdDbTable_mergedHeight(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public uint mergedWidth(uint row, uint column)
		{
			uint result = TD_DbPINVOKE.OdDbTable_mergedWidth(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool mergedFlag(uint row, uint column)
		{
			bool result = TD_DbPINVOKE.OdDbTable_mergedFlag(this.swigCPtr, row, column);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult generateLayout()
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_generateLayout(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult recomputeTableBlock(bool forceUpdate)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_recomputeTableBlock__SWIG_0(this.swigCPtr, forceUpdate);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult recomputeTableBlock()
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_recomputeTableBlock__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool hitTest(OdGePoint3d wpt, OdGeVector3d wviewVec, double wxaper, double wyaper, out int resultRowIndex, out int resultColumnIndex)
		{
			bool result = TD_DbPINVOKE.OdDbTable_hitTest__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(wpt), OdGeVector3d.getCPtr(wviewVec), wxaper, wyaper, out resultRowIndex, out resultColumnIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool hitTest(OdGePoint3d wpt, OdGeVector3d wviewVec, double wxaper, double wyaper, out int resultRowIndex, out int resultColumnIndex, out int contentIndex, out TableHitItem nItem)
		{
			bool result = TD_DbPINVOKE.OdDbTable_hitTest__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(wpt), OdGeVector3d.getCPtr(wviewVec), wxaper, wyaper, out resultRowIndex, out resultColumnIndex, out contentIndex, out nItem);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult select(OdGePoint3d wpt, OdGeVector3d wvwVec, OdGeVector3d wvwxVec, double wxaper, double wyaper, bool allowOutside, bool bInPickFirst, out int resultRowIndex, out int resultColumnIndex, OdDbFullSubentPathArray pPaths)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_select__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(wpt), OdGeVector3d.getCPtr(wvwVec), OdGeVector3d.getCPtr(wvwxVec), wxaper, wyaper, allowOutside, bInPickFirst, out resultRowIndex, out resultColumnIndex, OdDbFullSubentPathArray.getCPtr(pPaths));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult select(OdGePoint3d wpt, OdGeVector3d wvwVec, OdGeVector3d wvwxVec, double wxaper, double wyaper, bool allowOutside, bool bInPickFirst, out int resultRowIndex, out int resultColumnIndex)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_select__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(wpt), OdGeVector3d.getCPtr(wvwVec), OdGeVector3d.getCPtr(wvwxVec), wxaper, wyaper, allowOutside, bInPickFirst, out resultRowIndex, out resultColumnIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult selectSubRegion(OdGePoint3d wpt1, OdGePoint3d wpt2, OdGeVector3d wvwVec, OdGeVector3d wvwxVec, double wxaper, double wyaper, SelectType seltype, bool bIncludeCurrentSelection, bool bInPickFirst, out int rowMin, out int rowMax, out int colMin, out int colMax, OdDbFullSubentPathArray pPaths)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_selectSubRegion__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(wpt1), OdGePoint3d.getCPtr(wpt2), OdGeVector3d.getCPtr(wvwVec), OdGeVector3d.getCPtr(wvwxVec), wxaper, wyaper, (int)seltype, bIncludeCurrentSelection, bInPickFirst, out rowMin, out rowMax, out colMin, out colMax, OdDbFullSubentPathArray.getCPtr(pPaths));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult selectSubRegion(OdGePoint3d wpt1, OdGePoint3d wpt2, OdGeVector3d wvwVec, OdGeVector3d wvwxVec, double wxaper, double wyaper, SelectType seltype, bool bIncludeCurrentSelection, bool bInPickFirst, out int rowMin, out int rowMax, out int colMin, out int colMax)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_selectSubRegion__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(wpt1), OdGePoint3d.getCPtr(wpt2), OdGeVector3d.getCPtr(wvwVec), OdGeVector3d.getCPtr(wvwxVec), wxaper, wyaper, (int)seltype, bIncludeCurrentSelection, bInPickFirst, out rowMin, out rowMax, out colMin, out colMax);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual bool reselectSubRegion(OdDbFullSubentPathArray paths)
		{
			bool result = TD_DbPINVOKE.OdDbTable_reselectSubRegion(this.swigCPtr, OdDbFullSubentPathArray.getCPtr(paths));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult getSubSelection(out int rowMin, out int rowMax, out int colMin, out int colMax)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_getSubSelection__SWIG_0(this.swigCPtr, out rowMin, out rowMax, out colMin, out colMax);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdCellRange getSubSelection()
		{
			OdCellRange result = new OdCellRange(TD_DbPINVOKE.OdDbTable_getSubSelection__SWIG_1(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setSubSelection(OdCellRange range)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_setSubSelection__SWIG_0(this.swigCPtr, OdCellRange.getCPtr(range));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult setSubSelection(int rowMin, int rowMax, int colMin, int colMax)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_setSubSelection__SWIG_1(this.swigCPtr, rowMin, rowMax, colMin, colMax);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void clearSubSelection()
		{
			TD_DbPINVOKE.OdDbTable_clearSubSelection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual bool hasSubSelection()
		{
			bool result = TD_DbPINVOKE.OdDbTable_hasSubSelection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult select_next_cell(int dir, out int resultRowIndex, out int resultColumnIndex, OdDbFullSubentPathArray pPaths, bool bSupportTextCellOnly)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_select_next_cell__SWIG_0(this.swigCPtr, dir, out resultRowIndex, out resultColumnIndex, OdDbFullSubentPathArray.getCPtr(pPaths), bSupportTextCellOnly);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult select_next_cell(int dir, out int resultRowIndex, out int resultColumnIndex, OdDbFullSubentPathArray pPaths)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_select_next_cell__SWIG_1(this.swigCPtr, dir, out resultRowIndex, out resultColumnIndex, OdDbFullSubentPathArray.getCPtr(pPaths));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdResult select_next_cell(int dir, out int resultRowIndex, out int resultColumnIndex)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_select_next_cell__SWIG_2(this.swigCPtr, dir, out resultRowIndex, out resultColumnIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdResult dwgInFields(OdDbDwgFiler pFiler)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_dwgInFields(this.swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void dwgOutFields(OdDbDwgFiler pFiler)
		{
			TD_DbPINVOKE.OdDbTable_dwgOutFields(this.swigCPtr, OdDbDwgFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult dxfInFields(OdDbDxfFiler pFiler)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_dxfInFields(this.swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void dxfOutFields(OdDbDxfFiler pFiler)
		{
			TD_DbPINVOKE.OdDbTable_dxfOutFields(this.swigCPtr, OdDbDxfFiler.getCPtr(pFiler));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void subClose()
		{
			TD_DbPINVOKE.OdDbTable_subClose(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void subSetDatabaseDefaults(OdDbDatabase pDb, bool doSubents)
		{
			TD_DbPINVOKE.OdDbTable_subSetDatabaseDefaults(this.swigCPtr, OdDbDatabase.getCPtr(pDb), doSubents);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void modified(OdDbObject pObj)
		{
			TD_DbPINVOKE.OdDbTable_modified(this.swigCPtr, OdDbObject.getCPtr(pObj));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult subGetClassID(IntPtr pClsid)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_subGetClassID(this.swigCPtr, pClsid);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual bool subWorldDraw(OdGiWorldDraw pWd)
		{
			bool result = TD_DbPINVOKE.OdDbTable_subWorldDraw(this.swigCPtr, OdGiWorldDraw.getCPtr(pWd));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdResult subTransformBy(OdGeMatrix3d xfm)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_subTransformBy(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual OdResult subGetTransformedCopy(OdGeMatrix3d xfm, out OdDbEntity pCopy)
		{
			IntPtr zero = IntPtr.Zero;
			OdResult result;
			try
			{
				OdResult odResult = (OdResult)TD_DbPINVOKE.OdDbTable_subGetTransformedCopy(this.swigCPtr, OdGeMatrix3d.getCPtr(xfm), out zero);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
				result = odResult;
			}
			finally
			{
				pCopy = (OdDbEntity)Teigha.Core.Helpers.odrxCreateObjectInternal(zero, true);
			}
			return result;
		}

		public new virtual OdResult subGetGeomExtents(OdGeExtents3d extents)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_subGetGeomExtents(this.swigCPtr, OdGeExtents3d.getCPtr(extents));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void getDataType(out OdValue.DataType nDataType, out OdValue.UnitType nUnitType, RowType type)
		{
			TD_DbPINVOKE.OdDbTable_getDataType__SWIG_0(this.swigCPtr, out nDataType, out nUnitType, (int)type);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setDataType(OdValue.DataType nDataType, OdValue.UnitType nUnitType)
		{
			TD_DbPINVOKE.OdDbTable_setDataType__SWIG_0(this.swigCPtr, (int)nDataType, (int)nUnitType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setDataType(OdValue.DataType nDataType, OdValue.UnitType nUnitType, int nRowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setDataType__SWIG_1(this.swigCPtr, (int)nDataType, (int)nUnitType, nRowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual string format(RowType type)
		{
			string result = TD_DbPINVOKE.OdDbTable_format__SWIG_0(this.swigCPtr, (int)type);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setFormat(string pszFormat)
		{
			TD_DbPINVOKE.OdDbTable_setFormat__SWIG_0(this.swigCPtr, pszFormat);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual void setFormat(string pszFormat, int nRowTypes)
		{
			TD_DbPINVOKE.OdDbTable_setFormat__SWIG_1(this.swigCPtr, pszFormat, nRowTypes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getDataType(uint row, uint col, out OdValue.DataType nDataType, out OdValue.UnitType nUnitType)
		{
			TD_DbPINVOKE.OdDbTable_getDataType__SWIG_1(this.swigCPtr, row, col, out nDataType, out nUnitType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDataType(uint row, uint col, OdValue.DataType nDataType, OdValue.UnitType nUnitType)
		{
			TD_DbPINVOKE.OdDbTable_setDataType__SWIG_2(this.swigCPtr, row, col, (int)nDataType, (int)nUnitType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdValue value(uint row, uint col)
		{
			OdValue result = new OdValue(TD_DbPINVOKE.OdDbTable_value__SWIG_0(this.swigCPtr, row, col), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setValue(uint row, uint col, OdValue val)
		{
			TD_DbPINVOKE.OdDbTable_setValue__SWIG_0(this.swigCPtr, row, col, OdValue.getCPtr(val));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setValue(uint row, uint col, ref string pszText, OdValue.ParseOption nOption)
		{
			IntPtr intPtr = Marshal.StringToCoTaskMemUni(pszText);
			IntPtr value = intPtr;
			try
			{
				TD_DbPINVOKE.OdDbTable_setValue__SWIG_1(this.swigCPtr, row, col, ref intPtr, (int)nOption);
				if (TD_DbPINVOKE.SWIGPendingException.Pending)
				{
					throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				if (intPtr != value)
				{
					pszText = Marshal.PtrToStringUni(intPtr);
				}
			}
		}

		public void resetValue(uint row, uint col)
		{
			TD_DbPINVOKE.OdDbTable_resetValue(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string format(uint row, uint col)
		{
			string result = TD_DbPINVOKE.OdDbTable_format__SWIG_1(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setFormat(uint row, uint col, string pszFormat)
		{
			TD_DbPINVOKE.OdDbTable_setFormat__SWIG_2(this.swigCPtr, row, col, pszFormat);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isBreakEnabled()
		{
			bool result = TD_DbPINVOKE.OdDbTable_isBreakEnabled(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void enableBreak(bool bEnable)
		{
			TD_DbPINVOKE.OdDbTable_enableBreak(this.swigCPtr, bEnable);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public TableBreakFlowDirection breakFlowDirection()
		{
			TableBreakFlowDirection result = (TableBreakFlowDirection)TD_DbPINVOKE.OdDbTable_breakFlowDirection(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBreakFlowDirection(TableBreakFlowDirection flowDir)
		{
			TD_DbPINVOKE.OdDbTable_setBreakFlowDirection(this.swigCPtr, (int)flowDir);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double breakHeight(uint index)
		{
			double result = TD_DbPINVOKE.OdDbTable_breakHeight(this.swigCPtr, index);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBreakHeight(uint index, double height)
		{
			TD_DbPINVOKE.OdDbTable_setBreakHeight(this.swigCPtr, index, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGeVector3d breakOffset(uint index)
		{
			OdGeVector3d result = new OdGeVector3d(TD_DbPINVOKE.OdDbTable_breakOffset(this.swigCPtr, index), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBreakOffset(uint index, OdGeVector3d vec)
		{
			TD_DbPINVOKE.OdDbTable_setBreakOffset(this.swigCPtr, index, OdGeVector3d.getCPtr(vec));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public TableBreakOption breakOption()
		{
			TableBreakOption result = (TableBreakOption)TD_DbPINVOKE.OdDbTable_breakOption(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBreakOption(TableBreakOption option)
		{
			TD_DbPINVOKE.OdDbTable_setBreakOption(this.swigCPtr, (int)option);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double breakSpacing()
		{
			double result = TD_DbPINVOKE.OdDbTable_breakSpacing(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBreakSpacing(double spacing)
		{
			TD_DbPINVOKE.OdDbTable_setBreakSpacing(this.swigCPtr, spacing);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setSize(int rows, int cols)
		{
			TD_DbPINVOKE.OdDbTable_setSize(this.swigCPtr, rows, cols);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool canInsert(int nIndex, bool bRow)
		{
			bool result = TD_DbPINVOKE.OdDbTable_canInsert(this.swigCPtr, nIndex, bRow);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void insertRowsAndInherit(int nIndex, int nInheritFrom, int nNumRows)
		{
			TD_DbPINVOKE.OdDbTable_insertRowsAndInherit(this.swigCPtr, nIndex, nInheritFrom, nNumRows);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void insertColumnsAndInherit(int col, int nInheritFrom, int nNumCols)
		{
			TD_DbPINVOKE.OdDbTable_insertColumnsAndInherit(this.swigCPtr, col, nInheritFrom, nNumCols);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool canDelete(int nIndex, int nCount, bool bRow)
		{
			bool result = TD_DbPINVOKE.OdDbTable_canDelete(this.swigCPtr, nIndex, nCount, bRow);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isEmpty(int row, int col)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isEmpty(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdCellRange getMergeRange(int row, int col)
		{
			OdCellRange result = new OdCellRange(TD_DbPINVOKE.OdDbTable_getMergeRange(this.swigCPtr, row, col), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isContentEditable(int row, int col)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isContentEditable(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public bool isFormatEditable(int row, int col)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isFormatEditable(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public CellState cellState(int row, int col)
		{
			CellState result = (CellState)TD_DbPINVOKE.OdDbTable_cellState(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setCellState(int row, int col, CellState nLock)
		{
			TD_DbPINVOKE.OdDbTable_setCellState(this.swigCPtr, row, col, (int)nLock);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int numContents(int row, int col)
		{
			int result = TD_DbPINVOKE.OdDbTable_numContents(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public int createContent(int row, int col, int nIndex)
		{
			int result = TD_DbPINVOKE.OdDbTable_createContent(this.swigCPtr, row, col, nIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void moveContent(int row, int col, int nFromIndex, int nToIndex)
		{
			TD_DbPINVOKE.OdDbTable_moveContent(this.swigCPtr, row, col, nFromIndex, nToIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void deleteContent(int row, int col)
		{
			TD_DbPINVOKE.OdDbTable_deleteContent__SWIG_0(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void deleteContent(int row, int col, int nIndex)
		{
			TD_DbPINVOKE.OdDbTable_deleteContent__SWIG_1(this.swigCPtr, row, col, nIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void deleteContent(OdCellRange range)
		{
			TD_DbPINVOKE.OdDbTable_deleteContent__SWIG_2(this.swigCPtr, OdCellRange.getCPtr(range));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public CellContentType contentType(int row, int col)
		{
			CellContentType result = (CellContentType)TD_DbPINVOKE.OdDbTable_contentType__SWIG_0(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public CellContentType contentType(int row, int col, int nIndex)
		{
			CellContentType result = (CellContentType)TD_DbPINVOKE.OdDbTable_contentType__SWIG_1(this.swigCPtr, row, col, nIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdValue value(int row, int col, int nContent)
		{
			OdValue result = new OdValue(TD_DbPINVOKE.OdDbTable_value__SWIG_1(this.swigCPtr, row, col, nContent), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdValue value(int row, int col, int nContent, OdValue.FormatOption nOption)
		{
			OdValue result = new OdValue(TD_DbPINVOKE.OdDbTable_value__SWIG_2(this.swigCPtr, row, col, nContent, (int)nOption), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setValue(int row, int col, int nContent, OdValue val)
		{
			TD_DbPINVOKE.OdDbTable_setValue__SWIG_2(this.swigCPtr, row, col, nContent, OdValue.getCPtr(val));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setValue(int row, int col, int nContent, OdValue val, OdValue.ParseOption nOption)
		{
			TD_DbPINVOKE.OdDbTable_setValue__SWIG_3(this.swigCPtr, row, col, nContent, OdValue.getCPtr(val), (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setValue(int row, int col, int nContent, string sText, OdValue.ParseOption nOption)
		{
			TD_DbPINVOKE.OdDbTable_setValue__SWIG_4(this.swigCPtr, row, col, nContent, sText, (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string dataFormat(int row, int col)
		{
			string result = TD_DbPINVOKE.OdDbTable_dataFormat__SWIG_0(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string dataFormat(int row, int col, int nContent)
		{
			string result = TD_DbPINVOKE.OdDbTable_dataFormat__SWIG_1(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDataFormat(int row, int col, string sFormat)
		{
			TD_DbPINVOKE.OdDbTable_setDataFormat__SWIG_0(this.swigCPtr, row, col, sFormat);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDataFormat(int row, int col, int nContent, string sFormat)
		{
			TD_DbPINVOKE.OdDbTable_setDataFormat__SWIG_1(this.swigCPtr, row, col, nContent, sFormat);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string textString(int row, int col, int nContent)
		{
			string result = TD_DbPINVOKE.OdDbTable_textString__SWIG_1(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string textString(int row, int col, int nContent, OdValue.FormatOption nOption)
		{
			string result = TD_DbPINVOKE.OdDbTable_textString__SWIG_2(this.swigCPtr, row, col, nContent, (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string textString(int row, int col, OdValue.FormatOption nOption)
		{
			string result = TD_DbPINVOKE.OdDbTable_textString__SWIG_3(this.swigCPtr, row, col, (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextString(int row, int col, int nContent, string text)
		{
			TD_DbPINVOKE.OdDbTable_setTextString__SWIG_1(this.swigCPtr, row, col, nContent, text);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool hasFormula(int row, int col, int nContent)
		{
			bool result = TD_DbPINVOKE.OdDbTable_hasFormula(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public string getFormula(int row, int col, int nContent)
		{
			string result = TD_DbPINVOKE.OdDbTable_getFormula(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setFormula(int row, int col, int nContent, string pszFormula)
		{
			TD_DbPINVOKE.OdDbTable_setFormula(this.swigCPtr, row, col, nContent, pszFormula);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId fieldId(int row, int col, int nContent)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_fieldId__SWIG_1(this.swigCPtr, row, col, nContent);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setFieldId(int row, int col, int nContent, OdDbObjectId fieldId, CellOption nFlag)
		{
			TD_DbPINVOKE.OdDbTable_setFieldId__SWIG_1(this.swigCPtr, row, col, nContent, OdDbObjectId.getCPtr(fieldId), (int)nFlag);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId blockTableRecordId(int row, int col, int nContent)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_blockTableRecordId__SWIG_1(this.swigCPtr, row, col, nContent);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBlockTableRecordId(int row, int col, int nContent, OdDbObjectId blkId, bool autoFit)
		{
			TD_DbPINVOKE.OdDbTable_setBlockTableRecordId__SWIG_2(this.swigCPtr, row, col, nContent, OdDbObjectId.getCPtr(blkId), autoFit);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string getBlockAttributeValue(int row, int col, int nContent, OdDbObjectId attdefId)
		{
			string result = TD_DbPINVOKE.OdDbTable_getBlockAttributeValue__SWIG_1(this.swigCPtr, row, col, nContent, OdDbObjectId.getCPtr(attdefId));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setBlockAttributeValue(int row, int col, int nContent, OdDbObjectId attdefId, string atrValue)
		{
			TD_DbPINVOKE.OdDbTable_setBlockAttributeValue__SWIG_1(this.swigCPtr, row, col, nContent, OdDbObjectId.getCPtr(attdefId), atrValue);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public int getCustomData(int row, int col)
		{
			int result = TD_DbPINVOKE.OdDbTable_getCustomData__SWIG_0(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setCustomData(int row, int col, int nData)
		{
			TD_DbPINVOKE.OdDbTable_setCustomData__SWIG_0(this.swigCPtr, row, col, nData);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdValue getCustomData(int row, int col, string sKey)
		{
			OdValue result = new OdValue(TD_DbPINVOKE.OdDbTable_getCustomData__SWIG_1(this.swigCPtr, row, col, sKey), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setCustomData(int row, int col, string sKey, OdValue pData)
		{
			TD_DbPINVOKE.OdDbTable_setCustomData__SWIG_1(this.swigCPtr, row, col, sKey, OdValue.getCPtr(pData));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string cellStyle(int row, int col)
		{
			string result = TD_DbPINVOKE.OdDbTable_cellStyle(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setCellStyle(int row, int col, string sCellStyle)
		{
			TD_DbPINVOKE.OdDbTable_setCellStyle(this.swigCPtr, row, col, sCellStyle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double margin(int row, int col, CellMargin nMargin)
		{
			double result = TD_DbPINVOKE.OdDbTable_margin(this.swigCPtr, row, col, (int)nMargin);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setMargin(int row, int col, CellMargin nMargins, double fMargin)
		{
			TD_DbPINVOKE.OdDbTable_setMargin(this.swigCPtr, row, col, (int)nMargins, fMargin);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdGePoint3d attachmentPoint(int row, int col, int content)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.OdDbTable_attachmentPoint__SWIG_1(this.swigCPtr, row, col, content), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdCmColor contentColor(int row, int col, int nContent)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_contentColor__SWIG_3(this.swigCPtr, row, col, nContent), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setContentColor(int row, int col, int nContent, OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setContentColor__SWIG_3(this.swigCPtr, row, col, nContent, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getDataType(int row, int col, int nContent, out OdValue.DataType nDataType, out OdValue.UnitType nUnitType)
		{
			TD_DbPINVOKE.OdDbTable_getDataType__SWIG_2(this.swigCPtr, row, col, nContent, out nDataType, out nUnitType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDataType(int row, int col, int nContent, OdValue.DataType nDataType, OdValue.UnitType nUnitType)
		{
			TD_DbPINVOKE.OdDbTable_setDataType__SWIG_3(this.swigCPtr, row, col, nContent, (int)nDataType, (int)nUnitType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId textStyle(int row, int col, int nContent)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_textStyle__SWIG_3(this.swigCPtr, row, col, nContent);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextStyle(int row, int col, int nContent, OdDbObjectId id)
		{
			TD_DbPINVOKE.OdDbTable_setTextStyle__SWIG_3(this.swigCPtr, row, col, nContent, OdDbObjectId.getCPtr(id));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double textHeight(int row, int col, int nContent)
		{
			double result = TD_DbPINVOKE.OdDbTable_textHeight__SWIG_3(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setTextHeight(int row, int col, int nContent, double height)
		{
			TD_DbPINVOKE.OdDbTable_setTextHeight__SWIG_3(this.swigCPtr, row, col, nContent, height);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new double rotation()
		{
			double result = TD_DbPINVOKE.OdDbTable_rotation__SWIG_0(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public double rotation(int row, int col, int nContent)
		{
			double result = TD_DbPINVOKE.OdDbTable_rotation__SWIG_1(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public new virtual void setRotation(double fAngle)
		{
			TD_DbPINVOKE.OdDbTable_setRotation__SWIG_0(this.swigCPtr, fAngle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setRotation(int row, int col, int nContent, double fAngle)
		{
			TD_DbPINVOKE.OdDbTable_setRotation__SWIG_1(this.swigCPtr, row, col, nContent, fAngle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isAutoScale(int row, int col, int nContent)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isAutoScale__SWIG_1(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setAutoScale(int row, int col, int nContent, bool autoFit)
		{
			TD_DbPINVOKE.OdDbTable_setAutoScale__SWIG_1(this.swigCPtr, row, col, nContent, autoFit);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double scale(int row, int col, int nContent)
		{
			double result = TD_DbPINVOKE.OdDbTable_scale(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setScale(int row, int col, int nContent, double scale)
		{
			TD_DbPINVOKE.OdDbTable_setScale(this.swigCPtr, row, col, nContent, scale);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public CellContentLayout contentLayout(int row, int col)
		{
			CellContentLayout result = (CellContentLayout)TD_DbPINVOKE.OdDbTable_contentLayout(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setContentLayout(int row, int col, CellContentLayout nLayout)
		{
			TD_DbPINVOKE.OdDbTable_setContentLayout(this.swigCPtr, row, col, (int)nLayout);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isMergeAllEnabled(int row, int col)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isMergeAllEnabled(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void enableMergeAll(int row, int col, bool bEnable)
		{
			TD_DbPINVOKE.OdDbTable_enableMergeAll(this.swigCPtr, row, col, bEnable);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public CellProperty getOverride(int row, int col, int nContent)
		{
			CellProperty result = (CellProperty)TD_DbPINVOKE.OdDbTable_getOverride__SWIG_0(this.swigCPtr, row, col, nContent);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public GridProperty getOverride(int row, int col, GridLineType nGridLineType)
		{
			GridProperty result = (GridProperty)TD_DbPINVOKE.OdDbTable_getOverride__SWIG_1(this.swigCPtr, row, col, (int)nGridLineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setOverride(int row, int col, int nContent, CellProperty nOverride)
		{
			TD_DbPINVOKE.OdDbTable_setOverride__SWIG_0(this.swigCPtr, row, col, nContent, (int)nOverride);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setOverride(int row, int col, GridLineType nGridLineType, GridProperty nOverride)
		{
			TD_DbPINVOKE.OdDbTable_setOverride__SWIG_1(this.swigCPtr, row, col, (int)nGridLineType, (int)nOverride);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void removeAllOverrides(int row, int col)
		{
			TD_DbPINVOKE.OdDbTable_removeAllOverrides(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public GridLineStyle gridLineStyle(int row, int col, GridLineType nGridLineType)
		{
			GridLineStyle result = (GridLineStyle)TD_DbPINVOKE.OdDbTable_gridLineStyle(this.swigCPtr, row, col, (int)nGridLineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setGridLineStyle(int row, int col, GridLineType nGridLineTypes, GridLineStyle nLineStyle)
		{
			TD_DbPINVOKE.OdDbTable_setGridLineStyle(this.swigCPtr, row, col, (int)nGridLineTypes, (int)nLineStyle);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public LineWeight gridLineWeight(int row, int col, GridLineType nGridLineType)
		{
			LineWeight result = (LineWeight)TD_DbPINVOKE.OdDbTable_gridLineWeight__SWIG_3(this.swigCPtr, row, col, (int)nGridLineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setGridLineWeight(int row, int col, GridLineType nGridLineTypes, LineWeight nLineWeight)
		{
			TD_DbPINVOKE.OdDbTable_setGridLineWeight__SWIG_2(this.swigCPtr, row, col, (int)nGridLineTypes, (int)nLineWeight);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdDbObjectId gridLinetype(int row, int col, GridLineType nGridLineType)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_gridLinetype(this.swigCPtr, row, col, (int)nGridLineType);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setGridLinetype(int row, int col, GridLineType nGridLineTypes, OdDbObjectId idLinetype)
		{
			TD_DbPINVOKE.OdDbTable_setGridLinetype(this.swigCPtr, row, col, (int)nGridLineTypes, OdDbObjectId.getCPtr(idLinetype));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdCmColor gridColor(int row, int col, GridLineType nGridLineType)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.OdDbTable_gridColor__SWIG_3(this.swigCPtr, row, col, (int)nGridLineType), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setGridColor(int row, int col, GridLineType nGridlineTypes, OdCmColor color)
		{
			TD_DbPINVOKE.OdDbTable_setGridColor__SWIG_2(this.swigCPtr, row, col, (int)nGridlineTypes, OdCmColor.getCPtr(color));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public Visibility gridVisibility(int row, int col, GridLineType nGridLineType)
		{
			Visibility result = (Visibility)TD_DbPINVOKE.OdDbTable_gridVisibility__SWIG_3(this.swigCPtr, row, col, (int)nGridLineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setGridVisibility(int row, int col, GridLineType nGridLineTypes, Visibility nVisibility)
		{
			TD_DbPINVOKE.OdDbTable_setGridVisibility__SWIG_2(this.swigCPtr, row, col, (int)nGridLineTypes, (int)nVisibility);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public double gridDoubleLineSpacing(int row, int col, GridLineType nGridLineType)
		{
			double result = TD_DbPINVOKE.OdDbTable_gridDoubleLineSpacing(this.swigCPtr, row, col, (int)nGridLineType);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setGridDoubleLineSpacing(int row, int col, GridLineType nGridLineTypes, double fSpacing)
		{
			TD_DbPINVOKE.OdDbTable_setGridDoubleLineSpacing(this.swigCPtr, row, col, (int)nGridLineTypes, fSpacing);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void getGridProperty(int row, int col, GridLineType nGridLineType, OdGridProperty gridProp)
		{
			TD_DbPINVOKE.OdDbTable_getGridProperty(this.swigCPtr, row, col, (int)nGridLineType, OdGridProperty.getCPtr(gridProp));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setGridProperty(int row, int col, GridLineType nGridLineTypes, OdGridProperty gridProp)
		{
			TD_DbPINVOKE.OdDbTable_setGridProperty__SWIG_0(this.swigCPtr, row, col, (int)nGridLineTypes, OdGridProperty.getCPtr(gridProp));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setGridProperty(OdCellRange rangeIn, GridLineType nGridLineTypes, OdGridProperty gridProp)
		{
			TD_DbPINVOKE.OdDbTable_setGridProperty__SWIG_1(this.swigCPtr, OdCellRange.getCPtr(rangeIn), (int)nGridLineTypes, OdGridProperty.getCPtr(gridProp));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isLinked(int row, int col)
		{
			bool result = TD_DbPINVOKE.OdDbTable_isLinked(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbObjectId getDataLink(int row, int col)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.OdDbTable_getDataLink__SWIG_0(this.swigCPtr, row, col);
			OdDbObjectId result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdDbObjectId(cPtr, true));
				result = new OdDbObjectId(cPtr, false);
			}
			else
			{
				result = new OdDbObjectId(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public OdDbDataLink getDataLink(int row, int col, OpenMode mode)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.OdDbTable_getDataLink__SWIG_1(this.swigCPtr, row, col, (int)mode);
			OdDbDataLink result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbDataLink)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbDataLink)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbDataLink)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public int getDataLink(OdCellRange pRange, OdDbObjectIdArray dataLinkIds)
		{
			int result = TD_DbPINVOKE.OdDbTable_getDataLink__SWIG_2(this.swigCPtr, OdCellRange.getCPtr(pRange), OdDbObjectIdArray.getCPtr(dataLinkIds));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setDataLink(int row, int col, OdDbObjectId idDataLink, bool bUpdate)
		{
			TD_DbPINVOKE.OdDbTable_setDataLink__SWIG_0(this.swigCPtr, row, col, OdDbObjectId.getCPtr(idDataLink), bUpdate);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void setDataLink(OdCellRange range, OdDbObjectId idDataLink, bool bUpdate)
		{
			TD_DbPINVOKE.OdDbTable_setDataLink__SWIG_1(this.swigCPtr, OdCellRange.getCPtr(range), OdDbObjectId.getCPtr(idDataLink), bUpdate);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdCellRange getDataLinkRange(int row, int col)
		{
			OdCellRange result = new OdCellRange(TD_DbPINVOKE.OdDbTable_getDataLinkRange(this.swigCPtr, row, col), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void removeDataLink(int row, int col)
		{
			TD_DbPINVOKE.OdDbTable_removeDataLink__SWIG_0(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void removeDataLink()
		{
			TD_DbPINVOKE.OdDbTable_removeDataLink__SWIG_1(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void updateDataLink(int row, int col, UpdateDirection nDir, UpdateOption nOption)
		{
			TD_DbPINVOKE.OdDbTable_updateDataLink__SWIG_0(this.swigCPtr, row, col, (int)nDir, (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void updateDataLink(UpdateDirection nDir, UpdateOption nOption)
		{
			TD_DbPINVOKE.OdDbTable_updateDataLink__SWIG_1(this.swigCPtr, (int)nDir, (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string getColumnName(int nIndex)
		{
			string result = TD_DbPINVOKE.OdDbTable_getColumnName(this.swigCPtr, nIndex);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setColumnName(int nIndex, string sName)
		{
			TD_DbPINVOKE.OdDbTable_setColumnName(this.swigCPtr, nIndex, sName);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public string getToolTip(int row, int col)
		{
			string result = TD_DbPINVOKE.OdDbTable_getToolTip(this.swigCPtr, row, col);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void setToolTip(int row, int col, string sToolTip)
		{
			TD_DbPINVOKE.OdDbTable_setToolTip(this.swigCPtr, row, col, sToolTip);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void copyFrom(OdRxObject pSource)
		{
			TD_DbPINVOKE.OdDbTable_copyFrom__SWIG_0(this.swigCPtr, OdRxObject.getCPtr(pSource));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void copyFrom(OdDbLinkedTableData pSrc, TableCopyOption nOption)
		{
			TD_DbPINVOKE.OdDbTable_copyFrom__SWIG_1(this.swigCPtr, OdDbLinkedTableData.getCPtr(pSrc), (int)nOption);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void copyFrom(OdDbLinkedTableData pSrc, TableCopyOption nOption, OdCellRange srcRange, OdCellRange targetRange, OdCellRange pNewTargetRangeOut)
		{
			TD_DbPINVOKE.OdDbTable_copyFrom__SWIG_2(this.swigCPtr, OdDbLinkedTableData.getCPtr(pSrc), (int)nOption, OdCellRange.getCPtr(srcRange), OdCellRange.getCPtr(targetRange), OdCellRange.getCPtr(pNewTargetRangeOut));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void copyFrom(OdDbTable pSrc, TableCopyOption nOption, OdCellRange srcRange, OdCellRange targetRange, OdCellRange pNewTargetRangeOut)
		{
			TD_DbPINVOKE.OdDbTable_copyFrom__SWIG_3(this.swigCPtr, OdDbTable.getCPtr(pSrc), (int)nOption, OdCellRange.getCPtr(srcRange), OdCellRange.getCPtr(targetRange), OdCellRange.getCPtr(pNewTargetRangeOut));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual void appendToOwner(OdDbIdPair idPair, OdDbObject pOwnerObject, OdDbIdMapping ownerIdMap)
		{
			TD_DbPINVOKE.OdDbTable_appendToOwner(this.swigCPtr, OdDbIdPair.getCPtr(idPair), OdDbObject.getCPtr(pOwnerObject), OdDbIdMapping.getCPtr(ownerIdMap));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public bool isRegenerateTableSuppressed()
		{
			bool result = TD_DbPINVOKE.OdDbTable_isRegenerateTableSuppressed(this.swigCPtr);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void suppressRegenerateTable(bool bSuppress)
		{
			TD_DbPINVOKE.OdDbTable_suppressRegenerateTable(this.swigCPtr, bSuppress);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public new virtual OdResult subExplode(OdRxObjectPtrArray entitySet)
		{
			OdResult result = (OdResult)TD_DbPINVOKE.OdDbTable_subExplode(this.swigCPtr, OdRxObjectPtrArray.getCPtr(entitySet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		public enum TableStyleOverrides
		{
			kTitleSuppressed = 1,
			kHeaderSuppressed,
			kFlowDirection,
			kHorzCellMargin,
			kVertCellMargin,
			kTitleRowColor,
			kHeaderRowColor,
			kDataRowColor,
			kTitleRowFillNone,
			kHeaderRowFillNone,
			kDataRowFillNone,
			kTitleRowFillColor,
			kHeaderRowFillColor,
			kDataRowFillColor,
			kTitleRowAlignment,
			kHeaderRowAlignment,
			kDataRowAlignment,
			kTitleRowTextStyle,
			kHeaderRowTextStyle,
			kDataRowTextStyle,
			kTitleRowTextHeight,
			kHeaderRowTextHeight,
			kDataRowTextHeight,
			kTitleRowDataType,
			kHeaderRowDataType,
			kDataRowDataType,
			kTitleHorzTopColor = 40,
			kTitleHorzInsideColor,
			kTitleHorzBottomColor,
			kTitleVertLeftColor,
			kTitleVertInsideColor,
			kTitleVertRightColor,
			kHeaderHorzTopColor,
			kHeaderHorzInsideColor,
			kHeaderHorzBottomColor,
			kHeaderVertLeftColor,
			kHeaderVertInsideColor,
			kHeaderVertRightColor,
			kDataHorzTopColor,
			kDataHorzInsideColor,
			kDataHorzBottomColor,
			kDataVertLeftColor,
			kDataVertInsideColor,
			kDataVertRightColor,
			kTitleHorzTopLineWeight = 70,
			kTitleHorzInsideLineWeight,
			kTitleHorzBottomLineWeight,
			kTitleVertLeftLineWeight,
			kTitleVertInsideLineWeight,
			kTitleVertRightLineWeight,
			kHeaderHorzTopLineWeight,
			kHeaderHorzInsideLineWeight,
			kHeaderHorzBottomLineWeight,
			kHeaderVertLeftLineWeight,
			kHeaderVertInsideLineWeight,
			kHeaderVertRightLineWeight,
			kDataHorzTopLineWeight,
			kDataHorzInsideLineWeight,
			kDataHorzBottomLineWeight,
			kDataVertLeftLineWeight,
			kDataVertInsideLineWeight,
			kDataVertRightLineWeight,
			kTitleHorzTopVisibility = 100,
			kTitleHorzInsideVisibility,
			kTitleHorzBottomVisibility,
			kTitleVertLeftVisibility,
			kTitleVertInsideVisibility,
			kTitleVertRightVisibility,
			kHeaderHorzTopVisibility,
			kHeaderHorzInsideVisibility,
			kHeaderHorzBottomVisibility,
			kHeaderVertLeftVisibility,
			kHeaderVertInsideVisibility,
			kHeaderVertRightVisibility,
			kDataHorzTopVisibility,
			kDataHorzInsideVisibility,
			kDataHorzBottomVisibility,
			kDataVertLeftVisibility,
			kDataVertInsideVisibility,
			kDataVertRightVisibility,
			kCellAlignment = 130,
			kCellBackgroundFillNone,
			kCellBackgroundColor,
			kCellContentColor,
			kCellTextStyle,
			kCellTextHeight,
			kCellTopGridColor,
			kCellRightGridColor,
			kCellBottomGridColor,
			kCellLeftGridColor,
			kCellTopGridLineWeight,
			kCellRightGridLineWeight,
			kCellBottomGridLineWeight,
			kCellLeftGridLineWeight,
			kCellTopVisibility,
			kCellRightVisibility,
			kCellBottomVisibility,
			kCellLeftVisibility
		}
	}
}
